package service

import (
	"admin-nexus-backend/internal/model"
	"fmt"
	"strings"

	"gorm.io/gorm"
)

// DataPermissionService 数据权限服务
type DataPermissionService struct {
	DB *gorm.DB
}

// NewDataPermissionService 创建数据权限服务实例
func NewDataPermissionService(db *gorm.DB) *DataPermissionService {
	return &DataPermissionService{DB: db}
}

// GetUserDataPermission 获取用户的数据权限信息
func (s *DataPermissionService) GetUserDataPermission(userID uint) (*UserDataPermission, error) {
	var user model.User
	if err := s.DB.Preload("Roles").Preload("Roles.DataPermission").First(&user, userID).Error; err != nil {
		return nil, err
	}

	// 确定用户的数据权限范围（取权限最小的数据范围）
	dataScope := int8(5) // 默认最大限制：自定义数据
	var customOrgIDs []uint

	// 检查是否有超级管理员角色（通常具有全部数据权限）
	hasSuperAdmin := false
	for _, role := range user.Roles {
		// 检查是否为超级管理员角色（可以根据实际情况修改判断条件）
		if role.Code == "admin" || role.Code == "super_admin" {
			hasSuperAdmin = true
			break
		}

		// 如果角色有数据权限配置
		if role.DataPermission != nil {
			// 取权限最小的数据范围
			if role.DataPermission.DataScope < dataScope {
				dataScope = role.DataPermission.DataScope
			}
			// 如果是自定义数据范围，收集组织ID
			if role.DataPermission.DataScope == 5 && role.DataPermission.OrgIDs != "" {
				for _, idStr := range strings.Split(role.DataPermission.OrgIDs, ",") {
					var orgID uint
					if _, err := fmt.Sscanf(idStr, "%d", &orgID); err == nil {
						customOrgIDs = append(customOrgIDs, orgID)
					}
				}
			}
		}
	}

	// 如果有超级管理员角色，设置为全部数据权限
	if hasSuperAdmin {
		dataScope = 1
	}

	return &UserDataPermission{
		UserID:       userID,
		OrgID:        user.OrgID,
		DataScope:    dataScope,
		CustomOrgIDs: customOrgIDs,
	}, nil
}

// UserDataPermission 用户数据权限信息
type UserDataPermission struct {
	UserID       uint   // 用户ID
	OrgID        uint   // 用户所属组织ID
	DataScope    int8   // 数据权限范围
	CustomOrgIDs []uint // 自定义组织ID列表
}

// BuildDataScopeCondition 构建数据权限条件
// modelType: 模型类型，用于确定需要过滤的字段名
// 支持的模型类型：user(用户), organization(组织), 其他业务模型
func (s *DataPermissionService) BuildDataScopeCondition(permission *UserDataPermission, modelType string) func(db *gorm.DB) *gorm.DB {
	return func(db *gorm.DB) *gorm.DB {
		// 根据不同数据权限范围构建条件
		switch permission.DataScope {
		case 1: // 全部数据
			return db
		case 2: // 本部门数据
			if modelType == "user" {
				return db.Where("org_id = ?", permission.OrgID)
			} else if modelType == "organization" {
				return db.Where("id = ?", permission.OrgID)
			} else {
				// 其他业务模型，假设字段名为 create_org_id
				return db.Where("create_org_id = ?", permission.OrgID)
			}
		case 3: // 本部门及以下数据
			// 获取组织及其子组织ID列表
			orgIDs, err := s.GetOrganizationAndChildrenIDs(permission.OrgID)
			if err != nil || len(orgIDs) == 0 {
				return db.Where("1 = 0") // 出错时返回空结果
			}
			if modelType == "user" {
				return db.Where("org_id IN ?", orgIDs)
			} else if modelType == "organization" {
				return db.Where("id IN ?", orgIDs)
			} else {
				return db.Where("create_org_id IN ?", orgIDs)
			}
		case 4: // 仅自己数据
			if modelType == "user" {
				return db.Where("id = ?", permission.UserID)
			} else {
				return db.Where("create_by = ?", permission.UserID)
			}
		case 5: // 自定义数据
			if modelType == "user" {
				return db.Where("org_id IN ?", permission.CustomOrgIDs)
			} else if modelType == "organization" {
				return db.Where("id IN ?", permission.CustomOrgIDs)
			} else {
				return db.Where("create_org_id IN ?", permission.CustomOrgIDs)
			}
		default:
			return db.Where("1 = 0") // 默认无权限
		}
	}
}

// GetOrganizationAndChildrenIDs 获取组织及其所有子组织的ID列表
func (s *DataPermissionService) GetOrganizationAndChildrenIDs(orgID uint) ([]uint, error) {
	var orgIDs []uint
	orgIDs = append(orgIDs, orgID)

	// 递归获取所有子组织ID
	var childrenOrgs []model.Organization
	if err := s.DB.Where("parent_id = ?", orgID).Find(&childrenOrgs).Error; err != nil {
		return nil, err
	}

	for _, childOrg := range childrenOrgs {
		childIDs, err := s.GetOrganizationAndChildrenIDs(childOrg.ID)
		if err != nil {
			return nil, err
		}
		orgIDs = append(orgIDs, childIDs...)
	}

	return orgIDs, nil
}

// UpdateRoleDataPermission 更新角色数据权限
func (s *DataPermissionService) UpdateRoleDataPermission(roleID uint, dataScope int8, orgIDs []uint) error {
	// 转换组织ID列表为字符串
	orgIDsStr := ""
	if len(orgIDs) > 0 {
		var idStrs []string
		for _, id := range orgIDs {
			idStrs = append(idStrs, fmt.Sprintf("%d", id))
		}
		orgIDsStr = strings.Join(idStrs, ",")
	}

	// 保存数据权限
	var permission model.RoleDataPermission
	result := s.DB.Where("role_id = ?", roleID).First(&permission)
	if result.Error == gorm.ErrRecordNotFound {
		// 创建新的权限记录
		permission = model.RoleDataPermission{
			RoleID:    roleID,
			DataScope: dataScope,
			OrgIDs:    orgIDsStr,
		}
		return s.DB.Create(&permission).Error
	} else if result.Error != nil {
		return result.Error
	}

	// 更新现有权限记录
	permission.DataScope = dataScope
	permission.OrgIDs = orgIDsStr
	return s.DB.Save(&permission).Error
}
